home *** CD-ROM | disk | FTP | other *** search
/ Tech Arsenal 1 / Tech Arsenal (Arsenal Computer).ISO / tek-01 / cppmatrx.zip / MATRIX.C < prev    next >
Text File  |  1991-02-02  |  9KB  |  381 lines
  1. #include <stdlib.h>
  2. #include <iostream.h>
  3. #include <stdarg.h>
  4. #include <math.h>
  5.  
  6. #include "matrix.h"
  7. #include "matparse.h"
  8.  
  9. matrix::matrix (size_t matrix_length, ...)
  10. {
  11.    if (matrix_length == 0)
  12.       matrix_error ("Cannot create a matrix of size 0.");
  13.  
  14.    va_list argptr;
  15.    size_t elem_count;
  16.  
  17.    matrix_size = matrix_length;
  18.    matrix_data = new matrix_t [matrix_size*matrix_size];
  19.  
  20.    matrix_t *i;
  21.    size_t count;
  22.  
  23.    va_start (argptr, matrix_length);
  24.  
  25.    elem_count = matrix_size*matrix_size;
  26.  
  27.    for (i = matrix_data, count = 1; count <= elem_count; i++, count++)  {
  28.          *i = (matrix_t) (va_arg (argptr, matrix_t));
  29.       }
  30.  
  31.    va_end (argptr);
  32. }
  33.  
  34. matrix::matrix (char *dummy, size_t matrix_length,matrix_t fill_value)
  35. {
  36.    if (matrix_length == 0)
  37.       matrix_error ("Cannot create a matrix of size 0.");
  38.  
  39.    size_t elem_count;
  40.  
  41.    matrix_size = matrix_length;
  42.    matrix_data = new matrix_t [matrix_size*matrix_size];
  43.  
  44.    matrix_t *i;
  45.    size_t count;
  46.  
  47.    elem_count = matrix_size*matrix_size;
  48.  
  49.    for (i = matrix_data, count = 1; count <= elem_count; count++, i++)
  50.       *i = (matrix_t) fill_value;
  51. }
  52.  
  53. void matrix::print_matrix (void)
  54. {
  55.    matrix_t *i;
  56.    size_t row_count, column_count;
  57.  
  58.    cout << '\n';
  59.  
  60.    for (i = matrix_data, row_count = 0, column_count = 0; row_count < matrix_size; i++)   {
  61.          cout << *i << ' ';
  62.          if (column_count == (matrix_size - 1)) {
  63.                column_count = 0;
  64.                row_count++;
  65.                cout << '\n';
  66.             }
  67.                else
  68.                   column_count++;
  69.       }
  70. }
  71.  
  72. matrix::matrix (matrix &m)
  73. {
  74.    matrix_t *i, *j;
  75.    size_t count, elem_count;
  76.  
  77.    matrix_size = m.matrix_size;
  78.    elem_count = matrix_size*matrix_size;
  79.  
  80.    matrix_data = new matrix_t [elem_count];
  81.  
  82.    for (i = matrix_data, j = m.matrix_data, count = 1; count <= elem_count; count++, i++, j++)
  83.       *i = *j;
  84. }
  85.  
  86. matrix matrix::operator= (matrix &m)
  87. {
  88.  
  89.    size_t elem_count;
  90.    matrix_t *i, *j;
  91.  
  92.    size_t count;
  93.  
  94.    delete matrix_data;  // erase the current contents of the matrix on the left
  95.                         // side of the assignment
  96.  
  97.    matrix_size = m.matrix_size;
  98.    elem_count = matrix_size * matrix_size;
  99.  
  100.    matrix_data = new matrix_t [elem_count];  // allocate space for the new matrix, identical to the argument
  101.  
  102.    for (i = matrix_data, j = m.matrix_data, count = 1; count <= elem_count; count++, i++, j++)
  103.       *i = *j;
  104.  
  105.    return *this;
  106. }
  107.  
  108. matrix matrix::operator+ (matrix m)
  109. {
  110.    if (matrix_size != m.matrix_size)
  111.       matrix_error ("Cannot add matrices of different sizes.");
  112.  
  113.    matrix temp ("*",matrix_size);
  114.    matrix_t *i, *j, *k;
  115.    size_t counter;
  116.    size_t elem_count;
  117.  
  118.    elem_count = matrix_size * matrix_size;
  119.  
  120.    for (i = matrix_data, j = m.matrix_data, k = temp.matrix_data, counter = 1;
  121.         counter <= elem_count; i++, j++, k++, counter++)
  122.            *k = *i + *j;
  123.  
  124.    return temp;
  125. }
  126.  
  127. matrix matrix::operator- (matrix m)
  128. {
  129.    if (matrix_size != m.matrix_size)
  130.       matrix_error ("Cannot subtract matrices of different sizes.");
  131.  
  132.    matrix temp ("*",matrix_size);
  133.    matrix_t *i, *j, *k;
  134.    size_t counter;
  135.    size_t elem_count;
  136.  
  137.    elem_count = matrix_size * matrix_size;
  138.  
  139.    for (i = matrix_data, j = m.matrix_data, k = temp.matrix_data, counter = 1;
  140.         counter <= elem_count; i++, j++, k++, counter++)
  141.            *k = *i - *j;
  142.  
  143.    return temp;
  144. }
  145.  
  146.  
  147. inline void swap (matrix_t &a, matrix_t &b)
  148. {
  149.    matrix_t temp;
  150.  
  151.    temp = a;
  152.    a = b;
  153.    b = temp;
  154. }
  155.  
  156.  
  157. void transpose (matrix &m)
  158. {
  159.    size_t i,j;
  160.  
  161.    for (i = 2; i <= m.matrix_size; i++)
  162.       for (j = 1; j <= i-1; j++)
  163.          swap (m (i,j), m (j,i));
  164. }
  165.  
  166.  
  167. matrix minor (matrix m, size_t m_row, size_t m_column)
  168. {
  169.    if (m_row == 0 || m_column == 0)
  170.       matrix_error ("Invalid matrix indices passed to function minor.");
  171.  
  172.    matrix temp ("*", m.matrix_size-1);
  173.    size_t column, row;
  174.    size_t temp_column, temp_row;
  175.    
  176.    for (column = 1, temp_column = 1; column <= m.matrix_size; column++)  {
  177.          if (column != m_column) {
  178.                for (row = 1, temp_row = 1; row <= m.matrix_size; row++)
  179.                   if (row != m_row) {
  180.                      temp (temp_row, temp_column) = m (row, column);
  181.                      temp_row++;
  182.                   }
  183.  
  184.                temp_column++;
  185.             }
  186.       }
  187.  
  188.    return temp;
  189. }
  190.  
  191.  
  192. matrix_t det (matrix m)
  193. {
  194.    if (m.matrix_size == 1)
  195.       matrix_error ("Cannot evaluate the determinate of a matrix of size 1.");
  196.  
  197.    if (m.matrix_size == 2)
  198.       return m (1,1)*m (2,2) - m (1,2)*m (2,1);
  199.          else  {
  200.                  size_t i;
  201.                  matrix_t value = 0;
  202.  
  203.                  for (i = 1; i <= m.matrix_size; i++)
  204.                     value += m (1,i) * cofactor (m, 1, i);
  205.  
  206.                  return value;
  207.             }
  208. }
  209.  
  210.  
  211.  
  212. int matrix::operator== (matrix m)
  213. {
  214.  
  215.    if (matrix_size == m.matrix_size)
  216.       return ! memcmp (matrix_data, m.matrix_data, matrix_size*matrix_size);
  217.          else
  218.             return 0;
  219. }
  220.  
  221.  
  222. int matrix::operator!= (matrix m)
  223. {
  224.  
  225.    if (matrix_size == m.matrix_size)
  226.       return memcmp (matrix_data, m.matrix_data, matrix_size*matrix_size);
  227.          else
  228.             return 1;
  229. }
  230.  
  231. matrix operator* (matrix m, double r)
  232. {
  233.    matrix temp ("*",m.matrix_size);
  234.    matrix_t *i, *t;
  235.    size_t count, elem_count = m.matrix_size*m.matrix_size;
  236.  
  237.    for (i = m.matrix_data, t = temp.matrix_data, count = 1; count <= elem_count; i++, t++, count++)
  238.       *t = *i * r;
  239.  
  240.    return temp;
  241. }
  242.  
  243. matrix operator* (double r, matrix m)
  244. {
  245.    matrix temp ("*",m.matrix_size);
  246.    matrix_t *i, *t;
  247.    size_t count, elem_count = m.matrix_size*m.matrix_size;
  248.  
  249.    for (i = m.matrix_data, t = temp.matrix_data, count = 1; count <= elem_count; i++, t++, count++)
  250.       *t = *i * r;
  251.  
  252.    return temp;
  253. }
  254.  
  255. matrix operator* (matrix m, int r)
  256. {
  257.    matrix temp ("*",m.matrix_size);
  258.    matrix_t *i, *t;
  259.    size_t count, elem_count = m.matrix_size*m.matrix_size;
  260.  
  261.    for (i = m.matrix_data, t = temp.matrix_data, count = 1; count <= elem_count; i++, t++, count++)
  262.       *t = *i * r;
  263.  
  264.    return temp;
  265. }
  266.  
  267. matrix operator* (int r, matrix m)
  268. {
  269.    matrix temp ("*",m.matrix_size);
  270.    matrix_t *i, *t;
  271.    size_t count, elem_count = m.matrix_size*m.matrix_size;
  272.  
  273.    for (i = m.matrix_data, t = temp.matrix_data, count = 1; count <= elem_count; i++, t++, count++)
  274.       *t = *i * r;
  275.  
  276.    return temp;
  277. }
  278.  
  279. matrix_t cofactor (matrix m, size_t m_row, size_t m_column)
  280. {
  281.    if (m_row == 0 || m_column == 0)
  282.       matrix_error ("Invalid matrix indices passed to function cofactor.");
  283.  
  284.    int factor;
  285.  
  286.    if ((m_row+m_column) % 2)
  287.       factor = (-1);
  288.          else
  289.             factor = 1;
  290.  
  291.    return (matrix_t) factor * det (minor (m, m_row, m_column));
  292. }
  293.  
  294.  
  295. matrix matrix::operator- (void)
  296. {
  297.    matrix temp ("*",matrix_size);
  298.    matrix_t *i, *t;
  299.    size_t count, elem_count = matrix_size*matrix_size;
  300.  
  301.    for (i = matrix_data, t = temp.matrix_data, count = 1; count <= elem_count; i++, t++, count++)
  302.       *t = -*i;
  303.  
  304.    return temp;
  305. }
  306.  
  307. matrix matrix::operator* (matrix m)
  308. {
  309.    if (matrix_size != m.matrix_size)
  310.       matrix_error ("Cannot multiply matrices of different dimensions.");
  311.  
  312.    size_t i,j,k;
  313.    matrix temp ("*",matrix_size);
  314.  
  315.    for (i = 1; i <= matrix_size; i++)  {
  316.  
  317.          for (j = 1; j <= matrix_size; j++)  {
  318.                matrix_t value = 0;
  319.  
  320.                for (k = 1; k <= matrix_size; k++)
  321.                   value += get_elem (j,k)*m (k,i);
  322.  
  323.                temp (j,i) = value;
  324.             }
  325.       }
  326.  
  327.    return temp;
  328. }
  329.  
  330.  
  331. ostream& operator<< (ostream &s, matrix m)
  332. {
  333.    size_t i,j;
  334.  
  335.    s << '\n';
  336.  
  337.    for (i = 1; i <= m.matrix_size; i++)   {
  338.          for (j = 1; j <= m.matrix_size; j++)
  339.             s << m (i,j) << ' ';
  340.  
  341.          s << '\n';
  342.       }
  343.  
  344.    return s;
  345. }
  346.  
  347. istream& operator>> (istream &s, matrix &m)
  348. {
  349.    size_t i,j;
  350.  
  351.    delete m.matrix_data;
  352.    s >> m.matrix_size;
  353.    m.matrix_data = new matrix_t [m.matrix_size*m.matrix_size];
  354.  
  355.    for (i = 1; i <= m.matrix_size; i++)   
  356.       for (j = 1; j <= m.matrix_size; j++)   
  357.             s >> m (i,j);
  358.  
  359.    return s;
  360. }
  361.  
  362. void matrix_error (char *message)
  363. {
  364.    cerr << "\nMatrix error: " << message << '\n';
  365.    exit (1);
  366. }
  367.  
  368.  
  369. main (void)
  370. {
  371.    cout << "\nTesting matrix calculator.\n";
  372.    cout << "\nPlease enter a matrix expression:\n";
  373.    cout << expression ();
  374.    
  375.    return 0;
  376. }
  377.  
  378.  
  379.  
  380.  
  381.